package com.iaz.tech.tools.tasks.impl;
/**
 *  Copyright: 自由开发
 *  author: 赵黎民
 *  description： 基础任务Item ， 用于管理目标任务项目。
 *
 *  其他任务，都是基于BaseTaskItem 实现
 */
import java.util.HashMap;
import java.util.Map;

import com.iaz.tech.tools.tasks.ability.IScheduleAble;
import com.iaz.tech.tools.tasks.ability.ITaskItemAble;
import lombok.Data;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.iaz.tech.tools.common.utils.IChainNodeAble;
import com.iaz.tech.tools.common.utils.UtilTools;
/**
 * @author Zhao Limin
 * @see    
 */
@Data
public abstract class BaseTaskItem implements ITaskItemAble {
    private static long __iNNER_SERAILNO = 0L;
	private final static String _SERIAL_NO_LOCK = "_N_LOCK_FOR_SERIAL";

	/** 
     * 日志
     */
	private final static Logger logger = (Logger) LoggerFactory.getLogger(BaseTaskItem.class);

	private Long itemCode = 0L;
	/* 任务执行 */
    public static long MAX_WAITTING_TIME = 72000000;
    /* 任务名称 */
    private String label = "";
    /* fatherItem 是上级任务， 用于管理子任务  */
	//private ITaskItemAble fatherItem = null;
    private ITaskItemAble fatherItem = null;
	/* 任务的状态 */
	//private TaskItemState state = TaskItemState.UNKNOWN;
    private IChainNodeAble<ITaskItemAble> state = null;
	/* 子任务 */
	private Map<Long, IChainNodeAble<ITaskItemAble>> children = new HashMap<Long, IChainNodeAble<ITaskItemAble>>();
	
	/* 同步Synchronized */
	private static final String _CHILD_SYN_TILE = "__children";

	/* 表明任务 */
	private boolean running = true;

	/* 如果为0 的话， 则表示一直在睡眠，知道被唤醒 */
	private long sleepCount = 0L;

	/* 第一次运行 */
	private long pauseTime = 0l;
	/* 等待多少时间 */
	private long fowWatingTime = 0l;
	/* 时间戳 */
	private long currentTime = 0l;



	/**
	 * 获得任务的ID号，在系统重是唯一的
	 * @return 当前时间戳并合并000
	 */
	public static long GenerateItemCode() {
		long result = -1L;
		synchronized( BaseTaskItem._SERIAL_NO_LOCK ) {
			if( __iNNER_SERAILNO >= 999) {
				__iNNER_SERAILNO= 0L;
			}
			__iNNER_SERAILNO++;
			result = UtilTools.getCurrentTime() * 1000 + __iNNER_SERAILNO;
		}
		return result;
    }

	@Override
	public long thisItemID() {
		return this.getItemCode();
	}

	/**
	 * 增加子任务
	 * @param child
	 */
	public void addChild( IChainNodeAble<ITaskItemAble> child) {
		try {
			if( this.children == null ) {
				this.children = new HashMap<Long, IChainNodeAble<ITaskItemAble>>();
            }
            if( child == null ) return;

			synchronized(_CHILD_SYN_TILE) {
                long _item_code = child.chainIdentifyNo(); 
                if( _item_code < 0 ) return;
				if( !this.children.containsKey( _item_code  )) {
					this.children.put( _item_code , child );
				}
			}
		}catch(Exception e) {
			e.printStackTrace();
			logger.error("执行addChild 异常：" + e.getMessage() );
		}
	}
	/**
	 * 删除
	 * @param item
	 */
	public void removeChild(ITaskItemAble item) {
		try {
			if( this.children == null ) {
				return ;
            }	
            long itemcode = item.thisItemID();

            this.removeChild( itemcode );	 
		 
		}catch(Exception e) {
			e.printStackTrace();
			logger.error(" removeChild(ZXZBaseTaskItem item) 异常：" + e.getMessage() );
		}
    }
    /**
	 * 根据TaskItemId 删除子任务
	 * @param taskitemID
	 */
    public void removeChild(Long taskitemID) {
		try {
			if( this.children == null ) {
				return ;
			}			 
			synchronized( _CHILD_SYN_TILE) {
				
				if( this.children.containsKey( taskitemID  )) {
					this.children.remove( taskitemID );
				}
			}
		}catch(Exception e) {
			e.printStackTrace();
			logger.error("removeChild(Long taskitemID) 异常：" + e.getMessage() );
		}
	}
	/**
	 * 清除子任务
	 */
	public void clearChildren() {
		try {
			if( this.children == null ) {
				return ;
			}
			synchronized( _CHILD_SYN_TILE ) {
				this.children.clear();
			}
		}catch(Exception e) {
			e.printStackTrace();
			logger.error(" clearChildren() 异常：" + e.getMessage() );
		}
    }
	/**
	 * 判断子任务是否为空
	 * @return
	 */
    public boolean childEmpty(){
        synchronized( _CHILD_SYN_TILE) {
            return this.children == null ? true: this.children.isEmpty();
        }   
    }
    
    /**
     * 等待执行完毕，主要是子任务执行完毕。
     */
    public void waittingForEmptyChildTasks(){
        long S_TIME = UtilTools.getCurrentTime();
		if( this.children == null  ) return;
		while( true ) {
			try {
				
				long C_TIME = UtilTools.getCurrentTime();
				if( ( C_TIME - S_TIME ) >= MAX_WAITTING_TIME)  {
					throw new Exception("任务" + this.getLabel() + " 等待子任务超时!");
                }
				
				if( this.childEmpty() ){
                    break;
                }
			}catch(Exception e) {
                logger.error(" waittingForEmptyChildTasks() 执行异常：" + e.getMessage() );				
                break;
			}finally {
				try {
					Thread.sleep( 10 );
				}catch(Exception e2) {
					e2.printStackTrace();
					logger.error(" waittingForEmptyChildTasks() 执行Thread.sleep( 10 ) 异常：" + e2.getMessage() );
				}
			}
		}
    }

	 /**
     * 可执行时间
     * @return
     */
	@Override
    public long forExecuteTime() {
		return this.currentTime;
	}
}
